//! 控制台 Appender
//!
//! 将日志输出到控制台（stdout 或 stderr）。
//!
//! ## 主要类型
//!
//! - [`ConsoleAppender`] - 控制台输出 Appender
//! - [`ConsoleTarget`] - 输出目标枚举（Stdout/Stderr）
//!
//! ## 示例
//!
//! ```rust
//! use log4r::appender::{Appender, ConsoleAppender, ConsoleTarget};
//! use log4r::{Level, LogEvent};
//!
//! // 默认配置：stdout
//! let appender = ConsoleAppender::new();
//!
//! // 指定输出目标
//! let appender = ConsoleAppender::with_target(ConsoleTarget::Stderr);
//!
//! // 写入日志
//! let event = LogEvent::new(Level::Info, "my_app", "Hello, world!");
//! appender.write(&event).ok();
//! ```

use std::io::{self, Stderr, Stdout, Write};
use std::sync::Mutex;

use crate::appender::Appender;
use crate::error::Log4rError;
use crate::event::LogEvent;
#[cfg(feature = "color")]
use crate::formatter::{should_colorize, ColoredFormatter};
use crate::formatter::{Formatter, TextFormatter};
use crate::level::Level;

/// 控制台输出目标
///
/// 指定日志输出到标准输出（stdout）或标准错误（stderr）。
///
/// # 示例
///
/// ```rust
/// use log4r::appender::ConsoleTarget;
///
/// let target = ConsoleTarget::default();
/// assert_eq!(target, ConsoleTarget::Stdout);
/// ```
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
pub enum ConsoleTarget {
    /// 标准输出 (stdout)
    #[default]
    Stdout,
    /// 标准错误 (stderr)
    Stderr,
}

/// 内部写入器枚举，封装 stdout 和 stderr
enum ConsoleWriter {
    Stdout(Mutex<Stdout>),
    Stderr(Mutex<Stderr>),
}

impl ConsoleWriter {
    /// 写入字符串并换行
    fn write_line(&self, s: &str) -> io::Result<()> {
        match self {
            ConsoleWriter::Stdout(mutex) => {
                let mut writer = mutex.lock().map_err(|_| io::Error::other("获取锁失败"))?;
                writeln!(writer, "{}", s)
            }
            ConsoleWriter::Stderr(mutex) => {
                let mut writer = mutex.lock().map_err(|_| io::Error::other("获取锁失败"))?;
                writeln!(writer, "{}", s)
            }
        }
    }

    /// 刷新缓冲区
    fn flush(&self) -> io::Result<()> {
        match self {
            ConsoleWriter::Stdout(mutex) => {
                let mut writer = mutex.lock().map_err(|_| io::Error::other("获取锁失败"))?;
                writer.flush()
            }
            ConsoleWriter::Stderr(mutex) => {
                let mut writer = mutex.lock().map_err(|_| io::Error::other("获取锁失败"))?;
                writer.flush()
            }
        }
    }
}

/// 控制台日志输出器
///
/// 支持 stdout 和 stderr 两种输出目标，线程安全。
/// 支持配置独立的日志级别过滤。
///
/// # 示例
///
/// ```rust
/// use log4r::appender::{Appender, ConsoleAppender, ConsoleTarget};
/// use log4r::{Level, LogEvent};
///
/// // 默认配置：stdout，级别 Trace（不过滤）
/// let appender = ConsoleAppender::new();
///
/// // 指定输出目标
/// let appender = ConsoleAppender::with_target(ConsoleTarget::Stderr);
///
/// // 配置级别过滤：只输出 WARN 及以上级别
/// let appender = ConsoleAppender::new()
///     .with_level(Level::Warn);
///
/// // 使用自定义格式化器
/// use log4r::formatter::TextFormatter;
/// let appender = ConsoleAppender::new()
///     .with_formatter(Box::new(TextFormatter::new()));
/// ```
pub struct ConsoleAppender {
    /// 输出目标
    target: ConsoleTarget,
    /// 日志级别过滤阈值（低于此级别的日志被过滤）
    level: Level,
    /// 格式化器
    formatter: Box<dyn Formatter>,
    /// 写入器
    writer: ConsoleWriter,
}

// 编译时断言：验证 ConsoleAppender 实现 Send + Sync
const _: () = {
    const fn assert_send_sync<T: Send + Sync>() {}
    assert_send_sync::<ConsoleAppender>();
};

impl ConsoleAppender {
    /// 创建默认配置的 ConsoleAppender
    ///
    /// 默认输出到 stdout，使用 TextFormatter。
    ///
    /// # 示例
    ///
    /// ```rust
    /// use log4r::appender::ConsoleAppender;
    ///
    /// let appender = ConsoleAppender::new();
    /// ```
    pub fn new() -> Self {
        Self::with_target(ConsoleTarget::Stdout)
    }

    /// 创建指定输出目标的 ConsoleAppender
    ///
    /// # Arguments
    ///
    /// * `target` - 输出目标（Stdout 或 Stderr）
    ///
    /// # 示例
    ///
    /// ```rust
    /// use log4r::appender::{ConsoleAppender, ConsoleTarget};
    ///
    /// let stdout_appender = ConsoleAppender::with_target(ConsoleTarget::Stdout);
    /// let stderr_appender = ConsoleAppender::with_target(ConsoleTarget::Stderr);
    /// ```
    pub fn with_target(target: ConsoleTarget) -> Self {
        let writer = match target {
            ConsoleTarget::Stdout => ConsoleWriter::Stdout(Mutex::new(io::stdout())),
            ConsoleTarget::Stderr => ConsoleWriter::Stderr(Mutex::new(io::stderr())),
        };

        Self {
            target,
            level: Level::Trace, // 默认 Trace，不过滤任何日志
            formatter: Box::new(TextFormatter::new()),
            writer,
        }
    }

    /// 设置日志级别过滤阈值
    ///
    /// 低于此级别的日志将被过滤，不输出到控制台。
    /// 默认级别为 `Level::Trace`，即不过滤任何日志。
    ///
    /// # Arguments
    ///
    /// * `level` - 日志级别阈值
    ///
    /// # 示例
    ///
    /// ```rust
    /// use log4r::appender::ConsoleAppender;
    /// use log4r::Level;
    ///
    /// // 只输出 WARN 及以上级别的日志
    /// let appender = ConsoleAppender::new()
    ///     .with_level(Level::Warn);
    /// ```
    pub fn with_level(mut self, level: Level) -> Self {
        self.level = level;
        self
    }

    /// 获取当前日志级别过滤阈值
    ///
    /// # 示例
    ///
    /// ```rust
    /// use log4r::appender::ConsoleAppender;
    /// use log4r::Level;
    ///
    /// let appender = ConsoleAppender::new().with_level(Level::Warn);
    /// assert_eq!(appender.level(), Level::Warn);
    /// ```
    #[inline]
    pub fn level(&self) -> Level {
        self.level
    }

    /// 设置格式化器
    ///
    /// # Arguments
    ///
    /// * `formatter` - 格式化器实例
    ///
    /// # 示例
    ///
    /// ```rust
    /// use log4r::appender::ConsoleAppender;
    /// use log4r::formatter::TextFormatter;
    ///
    /// let appender = ConsoleAppender::new()
    ///     .with_formatter(Box::new(TextFormatter::new()));
    /// ```
    pub fn with_formatter(mut self, formatter: Box<dyn Formatter>) -> Self {
        self.formatter = formatter;
        self
    }

    /// 获取输出目标
    ///
    /// # 示例
    ///
    /// ```rust
    /// use log4r::appender::{ConsoleAppender, ConsoleTarget};
    ///
    /// let appender = ConsoleAppender::new();
    /// assert_eq!(appender.target(), ConsoleTarget::Stdout);
    /// ```
    #[inline]
    pub fn target(&self) -> ConsoleTarget {
        self.target
    }

    /// 启用彩色输出
    ///
    /// 使用 ANSI 颜色代码为不同日志级别显示不同颜色：
    /// - TRACE: 灰色
    /// - DEBUG: 蓝色
    /// - INFO: 绿色
    /// - WARN: 黄色
    /// - ERROR: 红色
    /// - FATAL: 亮红色 + 粗体
    ///
    /// 自动检测终端颜色支持：
    /// - 如果输出到支持颜色的终端，则显示彩色
    /// - 如果输出到文件或不支持颜色的终端，则显示纯文本
    ///
    /// 需要启用 `color` feature。
    ///
    /// # 示例
    ///
    /// ```rust,ignore
    /// use log4r::appender::ConsoleAppender;
    ///
    /// let appender = ConsoleAppender::new().with_colored();
    /// ```
    #[cfg(feature = "color")]
    pub fn with_colored(self) -> Self {
        // 根据终端检测决定是否启用彩色
        let enabled = should_colorize(true);
        let formatter = ColoredFormatter::new(enabled);
        self.with_formatter(Box::new(formatter))
    }
}

impl Default for ConsoleAppender {
    fn default() -> Self {
        Self::new()
    }
}

impl Appender for ConsoleAppender {
    /// 写入日志事件到控制台
    ///
    /// 首先检查日志级别，低于配置阈值的日志将被过滤。
    /// 通过过滤的日志使用格式化器格式化，然后写入到指定的输出目标。
    /// 每条日志后自动添加换行符。
    ///
    /// # Arguments
    ///
    /// * `event` - 要写入的日志事件
    ///
    /// # Returns
    ///
    /// * `Ok(())` - 写入成功或日志被过滤
    /// * `Err(Log4rError)` - 写入失败
    ///
    /// # 示例
    ///
    /// ```rust
    /// use log4r::appender::{Appender, ConsoleAppender};
    /// use log4r::{Level, LogEvent};
    ///
    /// let appender = ConsoleAppender::new().with_level(Level::Warn);
    ///
    /// // INFO < WARN，被过滤
    /// let info_event = LogEvent::new(Level::Info, "my_app", "Info message");
    /// appender.write(&info_event).ok(); // 不输出
    ///
    /// // WARN >= WARN，正常输出
    /// let warn_event = LogEvent::new(Level::Warn, "my_app", "Warning!");
    /// appender.write(&warn_event).ok(); // 输出
    /// ```
    fn write(&self, event: &LogEvent) -> Result<(), Log4rError> {
        // 级别过滤：低于阈值的日志直接返回
        if event.level < self.level {
            return Ok(());
        }

        // 格式化日志
        let formatted = self.formatter.format(event);

        // 写入并换行
        self.writer
            .write_line(&formatted)
            .map_err(Log4rError::IoError)
    }

    /// 刷新控制台缓冲区
    ///
    /// 确保所有已写入的数据都被刷新到控制台。
    ///
    /// # Returns
    ///
    /// * `Ok(())` - 刷新成功
    /// * `Err(Log4rError)` - 刷新失败
    fn flush(&self) -> Result<(), Log4rError> {
        self.writer.flush().map_err(Log4rError::IoError)
    }

    /// 关闭 ConsoleAppender
    ///
    /// 刷新缓冲区。控制台 Appender 不需要释放额外资源。
    ///
    /// # Returns
    ///
    /// * `Ok(())` - 关闭成功
    /// * `Err(Log4rError)` - 关闭失败
    fn close(&self) -> Result<(), Log4rError> {
        self.flush()
    }
}

#[cfg(test)]
#[allow(clippy::unwrap_used, clippy::expect_used, clippy::clone_on_copy)]
mod tests {
    use super::*;
    use crate::Level;

    // ========================================
    // AC-4.2.1: ConsoleTarget 测试
    // ========================================

    /// UT-4.2-001: 测试 ConsoleTarget 默认值为 Stdout
    #[test]
    fn test_console_target_default_is_stdout() {
        // GIVEN: ConsoleTarget
        // WHEN: 使用 default()
        let target = ConsoleTarget::default();

        // THEN: 应为 Stdout
        assert_eq!(target, ConsoleTarget::Stdout);
    }

    /// UT-4.2-002: 测试 ConsoleTarget 枚举变体
    #[test]
    fn test_console_target_variants() {
        // GIVEN/WHEN: 创建两种变体
        let stdout = ConsoleTarget::Stdout;
        let stderr = ConsoleTarget::Stderr;

        // THEN: 应不相等
        assert_ne!(stdout, stderr);
    }

    /// UT-4.2-003: 测试 ConsoleTarget 实现 Clone 和 Copy
    #[test]
    fn test_console_target_clone_copy() {
        // GIVEN: ConsoleTarget
        let target = ConsoleTarget::Stdout;

        // WHEN: Clone 和 Copy
        let cloned = target.clone();
        let copied = target;

        // THEN: 应相等
        assert_eq!(target, cloned);
        assert_eq!(target, copied);
    }

    // ========================================
    // AC-4.2.1: ConsoleAppender 构造函数测试
    // ========================================

    /// UT-4.2-004: 测试 ConsoleAppender::new() 默认配置
    #[test]
    fn test_console_appender_new_default() {
        // GIVEN/WHEN: 使用 new() 创建
        let appender = ConsoleAppender::new();

        // THEN: 应使用 stdout
        assert_eq!(appender.target(), ConsoleTarget::Stdout);
    }

    /// UT-4.2-005: 测试 ConsoleAppender::with_target(Stdout)
    #[test]
    fn test_console_appender_with_target_stdout() {
        // GIVEN/WHEN: 指定 Stdout
        let appender = ConsoleAppender::with_target(ConsoleTarget::Stdout);

        // THEN: 应使用 stdout
        assert_eq!(appender.target(), ConsoleTarget::Stdout);
    }

    /// UT-4.2-006: 测试 ConsoleAppender::with_target(Stderr)
    #[test]
    fn test_console_appender_with_target_stderr() {
        // GIVEN/WHEN: 指定 Stderr
        let appender = ConsoleAppender::with_target(ConsoleTarget::Stderr);

        // THEN: 应使用 stderr
        assert_eq!(appender.target(), ConsoleTarget::Stderr);
    }

    /// UT-4.2-007: 测试 ConsoleAppender::default()
    #[test]
    fn test_console_appender_default() {
        // GIVEN/WHEN: 使用 default()
        let appender = ConsoleAppender::default();

        // THEN: 应使用 stdout
        assert_eq!(appender.target(), ConsoleTarget::Stdout);
    }

    /// UT-4.2-008: 测试 with_formatter builder 方法
    #[test]
    fn test_console_appender_with_formatter() {
        // GIVEN: ConsoleAppender
        // WHEN: 使用 with_formatter
        let appender = ConsoleAppender::new().with_formatter(Box::new(TextFormatter::new()));

        // THEN: 应成功创建（验证不 panic）
        assert_eq!(appender.target(), ConsoleTarget::Stdout);
    }

    // ========================================
    // AC-4.2.2: 输出使用 Formatter 格式化
    // ========================================

    /// UT-4.2-009: 测试 write 方法使用 Formatter
    #[test]
    fn test_console_appender_uses_formatter() {
        // GIVEN: ConsoleAppender 和 LogEvent
        let appender = ConsoleAppender::new();
        let event = LogEvent::new(Level::Info, "test_app", "测试消息");

        // WHEN: 调用 write
        let result = appender.write(&event);

        // THEN: 应成功（格式化器被调用）
        assert!(result.is_ok());
    }

    // ========================================
    // AC-4.2.4: 线程安全测试
    // ========================================

    /// UT-4.2-010: 编译时验证 ConsoleAppender 实现 Send + Sync
    #[test]
    fn test_console_appender_is_send_sync() {
        // GIVEN/WHEN: 编译时断言函数
        fn assert_send_sync<T: Send + Sync>() {}

        // THEN: ConsoleAppender 应实现 Send + Sync（编译通过即验证成功）
        assert_send_sync::<ConsoleAppender>();
    }

    /// UT-4.2-011: 测试 ConsoleAppender 可作为 trait object
    #[test]
    fn test_console_appender_as_trait_object() {
        // GIVEN: ConsoleAppender
        let appender = ConsoleAppender::new();

        // WHEN: 转换为 trait object
        let _: &dyn Appender = &appender;
        let _: Box<dyn Appender> = Box::new(ConsoleAppender::new());

        // THEN: 编译通过即验证成功
    }

    /// UT-4.2-012: 测试多线程并发写入
    #[test]
    fn test_console_appender_concurrent_writes() {
        use std::sync::Arc;
        use std::thread;

        // GIVEN: 共享的 ConsoleAppender
        let appender = Arc::new(ConsoleAppender::new());
        let mut handles = vec![];

        // WHEN: 多线程并发写入
        for i in 0..4 {
            let appender_clone = Arc::clone(&appender);
            let handle = thread::spawn(move || {
                for j in 0..10 {
                    let event = LogEvent::new(
                        Level::Info,
                        "concurrent_test",
                        format!("Thread {} - Message {}", i, j),
                    );
                    // 忽略结果，主要验证不 panic
                    let _ = appender_clone.write(&event);
                }
            });
            handles.push(handle);
        }

        // THEN: 所有线程应成功完成
        for handle in handles {
            handle.join().ok();
        }
    }

    // ========================================
    // Appender trait 方法测试
    // ========================================

    /// UT-4.2-013: 测试 flush 方法
    #[test]
    fn test_console_appender_flush() {
        // GIVEN: ConsoleAppender
        let appender = ConsoleAppender::new();

        // WHEN: 调用 flush
        let result = appender.flush();

        // THEN: 应成功
        assert!(result.is_ok());
    }

    /// UT-4.2-014: 测试 close 方法
    #[test]
    fn test_console_appender_close() {
        // GIVEN: ConsoleAppender
        let appender = ConsoleAppender::new();

        // WHEN: 调用 close
        let result = appender.close();

        // THEN: 应成功
        assert!(result.is_ok());
    }

    /// UT-4.2-015: 测试所有日志级别都能写入
    #[test]
    fn test_console_appender_all_levels() {
        // GIVEN: ConsoleAppender
        let appender = ConsoleAppender::new();

        // WHEN/THEN: 所有级别都应成功写入
        for level in [
            Level::Trace,
            Level::Debug,
            Level::Info,
            Level::Warn,
            Level::Error,
            Level::Fatal,
        ] {
            let event = LogEvent::new(level, "test", format!("{:?} message", level));
            let result = appender.write(&event);
            assert!(result.is_ok(), "级别 {:?} 写入失败", level);
        }
    }

    // ========================================
    // AC-4.3.1: stderr 输出功能测试
    // ========================================

    /// UT-4.3-001: 测试 stderr appender 创建
    #[test]
    fn test_stderr_appender_creation() {
        // GIVEN/WHEN: 使用 with_target 创建 stderr appender
        let appender = ConsoleAppender::with_target(ConsoleTarget::Stderr);

        // THEN: 应正确配置为 stderr
        assert_eq!(appender.target(), ConsoleTarget::Stderr);
    }

    /// UT-4.3-002: 测试 stderr appender write 方法
    #[test]
    fn test_stderr_appender_write() {
        // GIVEN: stderr appender 和 LogEvent
        let appender = ConsoleAppender::with_target(ConsoleTarget::Stderr);
        let event = LogEvent::new(Level::Error, "stderr_test", "错误消息输出到 stderr");

        // WHEN: 调用 write
        let result = appender.write(&event);

        // THEN: 应成功写入（不 panic）
        assert!(result.is_ok());
    }

    /// UT-4.3-003: 测试 stderr appender flush 方法
    #[test]
    fn test_stderr_appender_flush() {
        // GIVEN: stderr appender
        let appender = ConsoleAppender::with_target(ConsoleTarget::Stderr);

        // WHEN: 调用 flush
        let result = appender.flush();

        // THEN: 应成功
        assert!(result.is_ok());
    }

    /// UT-4.3-004: 测试 stderr appender close 方法
    #[test]
    fn test_stderr_appender_close() {
        // GIVEN: stderr appender
        let appender = ConsoleAppender::with_target(ConsoleTarget::Stderr);

        // WHEN: 调用 close
        let result = appender.close();

        // THEN: 应成功
        assert!(result.is_ok());
    }

    // ========================================
    // AC-4.3.2: stderr 输出格式一致性测试
    // ========================================

    /// UT-4.3-005: 测试 stderr 使用相同的 Formatter
    #[test]
    fn test_stderr_uses_same_formatter() {
        // GIVEN: stdout 和 stderr appender
        let stdout_appender = ConsoleAppender::with_target(ConsoleTarget::Stdout);
        let stderr_appender = ConsoleAppender::with_target(ConsoleTarget::Stderr);

        // WHEN: 检查两者的 formatter 类型
        // THEN: 两者都使用 TextFormatter（默认）
        // 通过验证两者都能成功格式化相同的事件来间接验证
        let event = LogEvent::new(Level::Info, "format_test", "格式一致性测试");

        let stdout_result = stdout_appender.write(&event);
        let stderr_result = stderr_appender.write(&event);

        assert!(stdout_result.is_ok());
        assert!(stderr_result.is_ok());
    }

    /// UT-4.3-006: 测试 stderr 输出格式与 stdout 一致
    #[test]
    fn test_stderr_output_format_matches_stdout() {
        // GIVEN: stdout 和 stderr appender 使用相同的 formatter
        let formatter = TextFormatter::new();
        let event = LogEvent::new(Level::Warn, "format_test", "格式匹配测试");

        // WHEN: 使用相同的 formatter 格式化
        let formatted = formatter.format(&event);

        // THEN: 格式化结果应包含预期的组成部分
        assert!(formatted.contains("[WARN ]"));
        assert!(formatted.contains("format_test"));
        assert!(formatted.contains("格式匹配测试"));
    }

    /// UT-4.3-007: 测试 stderr 每条日志后自动换行
    #[test]
    fn test_stderr_appends_newline() {
        // GIVEN: stderr appender
        let appender = ConsoleAppender::with_target(ConsoleTarget::Stderr);

        // WHEN: 写入多条日志
        for i in 0..3 {
            let event = LogEvent::new(Level::Info, "newline_test", format!("消息 {}", i));
            let result = appender.write(&event);
            // THEN: 每条都应成功（writeln! 自动添加换行）
            assert!(result.is_ok());
        }
    }

    // ========================================
    // AC-4.3.3: stderr 线程安全测试
    // ========================================

    /// UT-4.3-008: 测试 stderr 多线程并发写入
    #[test]
    fn test_stderr_concurrent_writes() {
        use std::sync::Arc;
        use std::thread;

        // GIVEN: 共享的 stderr appender
        let appender = Arc::new(ConsoleAppender::with_target(ConsoleTarget::Stderr));
        let mut handles = vec![];

        // WHEN: 多线程并发写入 stderr
        for i in 0..4 {
            let appender_clone = Arc::clone(&appender);
            let handle = thread::spawn(move || {
                for j in 0..10 {
                    let event = LogEvent::new(
                        Level::Error,
                        "stderr_concurrent",
                        format!("Thread {} - Error {}", i, j),
                    );
                    // 验证不 panic，不数据竞争
                    let _ = appender_clone.write(&event);
                }
            });
            handles.push(handle);
        }

        // THEN: 所有线程应成功完成
        for handle in handles {
            assert!(handle.join().is_ok());
        }
    }

    /// UT-4.3-009: 测试 stderr appender 实现 Send + Sync
    #[test]
    fn test_stderr_appender_is_send_sync() {
        // GIVEN: stderr appender
        fn assert_send_sync<T: Send + Sync>() {}

        // WHEN/THEN: 编译通过即验证成功
        assert_send_sync::<ConsoleAppender>();

        // 额外验证：stderr appender 可以跨线程传递
        let appender = ConsoleAppender::with_target(ConsoleTarget::Stderr);
        let handle = std::thread::spawn(move || {
            let event = LogEvent::new(Level::Error, "send_test", "跨线程测试");
            appender.write(&event).is_ok()
        });
        assert!(handle.join().is_ok());
    }

    /// UT-4.3-010: 测试 stderr 所有日志级别都能写入
    #[test]
    fn test_stderr_all_levels() {
        // GIVEN: stderr appender
        let appender = ConsoleAppender::with_target(ConsoleTarget::Stderr);

        // WHEN/THEN: 所有级别都应成功写入到 stderr
        for level in [
            Level::Trace,
            Level::Debug,
            Level::Info,
            Level::Warn,
            Level::Error,
            Level::Fatal,
        ] {
            let event = LogEvent::new(level, "stderr_levels", format!("{:?} to stderr", level));
            let result = appender.write(&event);
            assert!(result.is_ok(), "级别 {:?} 写入 stderr 失败", level);
        }
    }

    // ========================================
    // AC-4.4.1: 级别过滤配置测试
    // ========================================

    /// UT-4.4-001: 测试 with_level() 方法正确设置级别阈值
    #[test]
    fn test_with_level_sets_filter_level() {
        // GIVEN: ConsoleAppender
        // WHEN: 使用 with_level 设置不同级别
        let appender_warn = ConsoleAppender::new().with_level(Level::Warn);
        let appender_error = ConsoleAppender::new().with_level(Level::Error);
        let appender_trace = ConsoleAppender::new().with_level(Level::Trace);

        // THEN: level() 应返回正确的级别
        assert_eq!(appender_warn.level(), Level::Warn);
        assert_eq!(appender_error.level(), Level::Error);
        assert_eq!(appender_trace.level(), Level::Trace);
    }

    /// UT-4.4-002: 测试默认级别为 Trace（不过滤任何日志）
    #[test]
    fn test_default_level_is_trace() {
        // GIVEN/WHEN: 创建默认 ConsoleAppender
        let appender = ConsoleAppender::new();

        // THEN: 默认级别应为 Trace
        assert_eq!(appender.level(), Level::Trace);
    }

    /// UT-4.4-003: 测试 with_level 可链式调用
    #[test]
    fn test_with_level_builder_chain() {
        // GIVEN/WHEN: 链式调用多个 builder 方法
        let appender = ConsoleAppender::new()
            .with_level(Level::Warn)
            .with_formatter(Box::new(TextFormatter::new()));

        // THEN: 所有配置应正确
        assert_eq!(appender.level(), Level::Warn);
        assert_eq!(appender.target(), ConsoleTarget::Stdout);
    }

    // ========================================
    // AC-4.4.2: 低于配置级别的日志被过滤
    // ========================================

    /// UT-4.4-004: 测试配置 WARN 级别时，INFO 日志被过滤
    #[test]
    fn test_level_filter_blocks_info_when_warn() {
        // GIVEN: 配置 WARN 级别的 appender
        let appender = ConsoleAppender::new().with_level(Level::Warn);
        let info_event = LogEvent::new(Level::Info, "filter_test", "INFO 消息");

        // WHEN: 写入 INFO 级别日志
        let result = appender.write(&info_event);

        // THEN: 应成功返回（日志被过滤，不输出）
        assert!(result.is_ok());
    }

    /// UT-4.4-005: 测试配置 WARN 级别时，DEBUG 日志被过滤
    #[test]
    fn test_level_filter_blocks_debug_when_warn() {
        // GIVEN: 配置 WARN 级别的 appender
        let appender = ConsoleAppender::new().with_level(Level::Warn);
        let debug_event = LogEvent::new(Level::Debug, "filter_test", "DEBUG 消息");

        // WHEN: 写入 DEBUG 级别日志
        let result = appender.write(&debug_event);

        // THEN: 应成功返回（日志被过滤）
        assert!(result.is_ok());
    }

    /// UT-4.4-006: 测试配置 WARN 级别时，TRACE 日志被过滤
    #[test]
    fn test_level_filter_blocks_trace_when_warn() {
        // GIVEN: 配置 WARN 级别的 appender
        let appender = ConsoleAppender::new().with_level(Level::Warn);
        let trace_event = LogEvent::new(Level::Trace, "filter_test", "TRACE 消息");

        // WHEN: 写入 TRACE 级别日志
        let result = appender.write(&trace_event);

        // THEN: 应成功返回（日志被过滤）
        assert!(result.is_ok());
    }

    // ========================================
    // AC-4.4.3: 等于或高于配置级别的日志正常输出
    // ========================================

    /// UT-4.4-007: 测试配置 WARN 级别时，WARN 日志正常输出
    #[test]
    fn test_level_filter_allows_warn_when_warn() {
        // GIVEN: 配置 WARN 级别的 appender
        let appender = ConsoleAppender::new().with_level(Level::Warn);
        let warn_event = LogEvent::new(Level::Warn, "filter_test", "WARN 消息");

        // WHEN: 写入 WARN 级别日志
        let result = appender.write(&warn_event);

        // THEN: 应成功输出
        assert!(result.is_ok());
    }

    /// UT-4.4-008: 测试配置 WARN 级别时，ERROR 日志正常输出
    #[test]
    fn test_level_filter_allows_error_when_warn() {
        // GIVEN: 配置 WARN 级别的 appender
        let appender = ConsoleAppender::new().with_level(Level::Warn);
        let error_event = LogEvent::new(Level::Error, "filter_test", "ERROR 消息");

        // WHEN: 写入 ERROR 级别日志
        let result = appender.write(&error_event);

        // THEN: 应成功输出
        assert!(result.is_ok());
    }

    /// UT-4.4-009: 测试配置 WARN 级别时，FATAL 日志正常输出
    #[test]
    fn test_level_filter_allows_fatal_when_warn() {
        // GIVEN: 配置 WARN 级别的 appender
        let appender = ConsoleAppender::new().with_level(Level::Warn);
        let fatal_event = LogEvent::new(Level::Fatal, "filter_test", "FATAL 消息");

        // WHEN: 写入 FATAL 级别日志
        let result = appender.write(&fatal_event);

        // THEN: 应成功输出
        assert!(result.is_ok());
    }

    /// UT-4.4-010: 测试配置 TRACE 级别时，所有级别日志都输出
    #[test]
    fn test_level_filter_trace_allows_all() {
        // GIVEN: 配置 TRACE 级别的 appender（默认）
        let appender = ConsoleAppender::new().with_level(Level::Trace);

        // WHEN/THEN: 所有级别都应成功输出
        for level in [
            Level::Trace,
            Level::Debug,
            Level::Info,
            Level::Warn,
            Level::Error,
            Level::Fatal,
        ] {
            let event = LogEvent::new(level, "trace_test", format!("{:?} 消息", level));
            let result = appender.write(&event);
            assert!(result.is_ok(), "级别 {:?} 应该通过 TRACE 过滤", level);
        }
    }

    /// UT-4.4-011: 测试配置 FATAL 级别时，只有 FATAL 日志输出
    #[test]
    fn test_level_filter_fatal_only() {
        // GIVEN: 配置 FATAL 级别的 appender
        let appender = ConsoleAppender::new().with_level(Level::Fatal);

        // WHEN/THEN: 只有 FATAL 级别应该输出
        // 低于 FATAL 的级别被过滤
        for level in [
            Level::Trace,
            Level::Debug,
            Level::Info,
            Level::Warn,
            Level::Error,
        ] {
            let event = LogEvent::new(level, "fatal_test", format!("{:?} 消息", level));
            let result = appender.write(&event);
            assert!(result.is_ok(), "级别 {:?} 应该被过滤（返回 Ok）", level);
        }

        // FATAL 级别应该输出
        let fatal_event = LogEvent::new(Level::Fatal, "fatal_test", "FATAL 消息");
        let result = appender.write(&fatal_event);
        assert!(result.is_ok());
    }

    // ========================================
    // AC-4.4.1-4.4.3: 级别过滤与 stdout/stderr 组合测试
    // ========================================

    /// UT-4.4-012: 测试级别过滤与 stdout 目标组合
    #[test]
    fn test_level_filter_with_stdout() {
        // GIVEN: stdout appender 配置 ERROR 级别
        let appender = ConsoleAppender::with_target(ConsoleTarget::Stdout).with_level(Level::Error);

        // THEN: 配置应正确
        assert_eq!(appender.target(), ConsoleTarget::Stdout);
        assert_eq!(appender.level(), Level::Error);

        // WHEN: 写入不同级别日志
        let warn_event = LogEvent::new(Level::Warn, "combo_test", "WARN");
        let error_event = LogEvent::new(Level::Error, "combo_test", "ERROR");

        // THEN: WARN 被过滤，ERROR 输出
        assert!(appender.write(&warn_event).is_ok());
        assert!(appender.write(&error_event).is_ok());
    }

    /// UT-4.4-013: 测试级别过滤与 stderr 目标组合
    #[test]
    fn test_level_filter_with_stderr() {
        // GIVEN: stderr appender 配置 ERROR 级别
        let appender = ConsoleAppender::with_target(ConsoleTarget::Stderr).with_level(Level::Error);

        // THEN: 配置应正确
        assert_eq!(appender.target(), ConsoleTarget::Stderr);
        assert_eq!(appender.level(), Level::Error);

        // WHEN: 写入不同级别日志
        let info_event = LogEvent::new(Level::Info, "combo_test", "INFO");
        let fatal_event = LogEvent::new(Level::Fatal, "combo_test", "FATAL");

        // THEN: INFO 被过滤，FATAL 输出
        assert!(appender.write(&info_event).is_ok());
        assert!(appender.write(&fatal_event).is_ok());
    }

    // ========================================
    // AC-4.4.4: 级别过滤线程安全测试
    // ========================================

    /// UT-4.4-014: 测试多线程并发写入时级别过滤正确工作
    #[test]
    fn test_level_filter_concurrent_writes() {
        use std::sync::Arc;
        use std::thread;

        // GIVEN: 共享的 appender，配置 WARN 级别
        let appender = Arc::new(ConsoleAppender::new().with_level(Level::Warn));
        let mut handles = vec![];

        // WHEN: 多线程并发写入不同级别的日志
        for i in 0..4 {
            let appender_clone = Arc::clone(&appender);
            let handle = thread::spawn(move || {
                for j in 0..10 {
                    // 交替写入 INFO（被过滤）和 ERROR（输出）
                    let level = if j % 2 == 0 {
                        Level::Info
                    } else {
                        Level::Error
                    };
                    let event = LogEvent::new(
                        level,
                        "concurrent_filter",
                        format!("Thread {} - {:?} {}", i, level, j),
                    );
                    // 验证不 panic，不数据竞争
                    let result = appender_clone.write(&event);
                    assert!(result.is_ok());
                }
            });
            handles.push(handle);
        }

        // THEN: 所有线程应成功完成
        for handle in handles {
            assert!(handle.join().is_ok());
        }
    }

    /// UT-4.4-015: 测试级别过滤不影响 Send + Sync
    #[test]
    fn test_level_filter_preserves_send_sync() {
        // GIVEN: 配置了级别过滤的 appender
        fn assert_send_sync<T: Send + Sync>() {}

        // WHEN/THEN: 编译通过即验证成功
        assert_send_sync::<ConsoleAppender>();

        // 额外验证：可以跨线程传递
        let appender = ConsoleAppender::new().with_level(Level::Error);
        let handle = std::thread::spawn(move || {
            assert_eq!(appender.level(), Level::Error);
            let event = LogEvent::new(Level::Fatal, "send_test", "跨线程测试");
            appender.write(&event).is_ok()
        });
        assert!(handle.join().is_ok());
    }

    // ========================================
    // AC-4.5: 彩色输出测试 (需要 color feature)
    // ========================================

    /// UT-4.5-001: 测试 with_colored() 方法创建彩色 appender
    #[cfg(feature = "color")]
    #[test]
    fn test_console_appender_with_colored() {
        // GIVEN/WHEN: 使用 with_colored() 创建 appender
        let appender = ConsoleAppender::new().with_colored();

        // THEN: 应成功创建
        assert_eq!(appender.target(), ConsoleTarget::Stdout);
    }

    /// UT-4.5-002: 测试彩色 appender 输出所有级别
    #[cfg(feature = "color")]
    #[test]
    fn test_colored_appender_all_levels() {
        // GIVEN: 彩色 appender
        let appender = ConsoleAppender::new().with_colored();

        // WHEN/THEN: 所有级别都应成功写入
        for level in [
            Level::Trace,
            Level::Debug,
            Level::Info,
            Level::Warn,
            Level::Error,
            Level::Fatal,
        ] {
            let event = LogEvent::new(level, "color_test", format!("{:?} 彩色消息", level));
            let result = appender.write(&event);
            assert!(result.is_ok(), "级别 {:?} 写入失败", level);
        }
    }

    /// UT-4.5-003: 测试 stderr 彩色输出
    #[cfg(feature = "color")]
    #[test]
    fn test_stderr_colored_appender() {
        // GIVEN: stderr 彩色 appender
        let appender = ConsoleAppender::with_target(ConsoleTarget::Stderr).with_colored();

        // WHEN: 写入日志
        let event = LogEvent::new(Level::Error, "stderr_color", "stderr 彩色错误消息");
        let result = appender.write(&event);

        // THEN: 应成功
        assert!(result.is_ok());
        assert_eq!(appender.target(), ConsoleTarget::Stderr);
    }

    /// UT-4.5-004: 测试彩色 appender 与级别过滤组合
    #[cfg(feature = "color")]
    #[test]
    fn test_colored_appender_with_level_filter() {
        // GIVEN: 彩色 appender 配置 WARN 级别过滤
        let appender = ConsoleAppender::new()
            .with_colored()
            .with_level(Level::Warn);

        // THEN: 配置应正确
        assert_eq!(appender.level(), Level::Warn);

        // WHEN: 写入不同级别日志
        let info_event = LogEvent::new(Level::Info, "filter_color", "INFO 被过滤");
        let error_event = LogEvent::new(Level::Error, "filter_color", "ERROR 彩色输出");

        // THEN: 都应返回 Ok（INFO 被过滤，ERROR 输出）
        assert!(appender.write(&info_event).is_ok());
        assert!(appender.write(&error_event).is_ok());
    }
}
